namespace Wang
{
class string
{
    char* _str = nullptr;         // 字符串
    size_t _size = 0;
    friend ostream& operator<< (ostream& out, const string& s);
public:
    // 用C语言的字符串构造
    string(const char* s = "")
    {
        cout << "string(const char* s = \"\")" << endl;
        _size = strlen(s);
        _str = new char[_size + 1];
        strcpy(_str, s);    // 此函数会拷贝'\0'
    }

    // 用n个字符c构造
    string (size_t n, char c)
        :_size(n)
        ,_str(new char[n + 1])
    {
        cout << "string (size_t n, char c)" << endl;
        memset(_str, c, sizeof(char) * n);  // memset是按字节初始化
        _str[n] = '\0';
    }

    // 拷贝构造
    string(const string& s)
    {
        cout << "string(const string& s)" << endl;
        _size = s._size;
        _str = new char[_size + 1];
        strcpy(_str, s._str);
    }

    // 移动构造
    string(string&& s)
    {
        cout << "string(string&& s)" << endl;
        std::swap(_str, s._str);
        std::swap(_size, s._size);
    }
};

ostream& operator<< (ostream& out, const string& s)
{
    out << s._str;
    return out;
}

// class A
// {
// 	Wang::string _s;
// public:
// 	A()
// 		:_s()	// 这里会调用默认构造
// 	{ }
// };

template<class T>
struct list_node
{
    T _data;
    list_node* _next;
    list_node* _prev;

    template<class ...Args>
    list_node(Args&&... args)
        :_data(forward<Args>(args)...)
        ,_next(this)
        ,_prev(this)
    {}

    list_node(string& s)
        :_data(s)
        ,_next(this)
        ,_prev(this)
    {}
    list_node(string&& s)
        :_data(move(s))
        ,_next(this)
        ,_prev(this)
    {}
    list_node(size_t n, char c)
        :_data(n, c)
        ,_next(this)
        ,_prev(this)
    {}
};

template<class T>
class list
{
    typedef list_node<T> node;
    node* _head = new node; // 带头双向循环链表
public:

    template<class ...Args>
    void emplace_back(Args&& ...args)
    {
        node* tail = _head->_prev;
        node* cur = new node(forward<Args>(args)...);
        cur->_prev = tail;
        cur->_next = _head;
        tail->_next = _head->_prev = cur;
    }
    void push_back(const T& x)
    {
        node* tail = _head->_prev;
        node* cur = new node(x);
        cur->_prev = tail;
        cur->_next = _head;
        tail->_next = _head->_prev = cur;
    }
    
    // void emplace_back(string& s)
    // {
    //     // ... 省略其他代码
    //     node* cur = new node(s);
    //     // ... 省略其他代码
    // }
    // void emplace_back(string&& s)
    // {
    //     // ... 省略其他代码
    //     node* cur = new node(move(s));  // 这里
    //     // ... 省略其他代码
    // }
    // void emplace_back(size_t n, char c)
    // {
    //     // ... 省略其他代码
    //     node* cur = new node(n, c);
    //     // ... 省略其他代码
    // }

    void print()
    {
        for(node* i = _head->_next; i != _head; i = i->_next)
            cout << i->_data << ' ';
        cout << endl;
    }
};
}
